package android.fwirk.twitter;

import java.io.File;
import java.net.URL;
import java.util.Date;
import java.util.List;

import android.graphics.Bitmap;

import twitter4j.Device;
import twitter4j.DirectMessage;
import twitter4j.GeoLocation;
import twitter4j.IDs;
import twitter4j.PagableResponseList;
import twitter4j.Paging;
import twitter4j.Query;
import twitter4j.QueryResult;
import twitter4j.RateLimitStatus;
import twitter4j.Relationship;
import twitter4j.ResponseList;
import twitter4j.SavedSearch;
import twitter4j.Status;
import twitter4j.Trends;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.User;
import twitter4j.UserList;
import twitter4j.http.AccessToken;
import twitter4j.http.RequestToken;

public class TwitterClient {
	Twitter twitter;
	TwitterUser user;

	public TwitterClient(Twitter twitter) {
		this.twitter = twitter;
	}

	public UserList addUserListMember(int listId, int userId)
			throws TwitterException {

		return twitter.addUserListMember(listId, userId);
	}

	public User checkUserListMembership(String listOwnerScreenName, int listId,
			int userId) throws TwitterException {

		return twitter.checkUserListMembership(listOwnerScreenName, listId,
				userId);
	}

	public User checkUserListSubscription(String listOwnerScreenName,
			int listId, int userId) throws TwitterException {

		return twitter.checkUserListSubscription(listOwnerScreenName, listId,
				userId);
	}

	public User createBlock(int userId) throws TwitterException {

		return twitter.createBlock(userId);
	}

	public User createBlock(String screenName) throws TwitterException {

		return twitter.createBlock(screenName);
	}

	public Status createFavorite(long id) throws TwitterException {

		return twitter.createFavorite(id);
	}

	public User createFriendship(int userId, boolean follow)
			throws TwitterException {

		return twitter.createFriendship(userId, follow);
	}

	public User createFriendship(int userId) throws TwitterException {

		return twitter.createFriendship(userId);
	}

	public User createFriendship(String screenName, boolean follow)
			throws TwitterException {

		return twitter.createFriendship(screenName, follow);
	}

	public User createFriendship(String screenName) throws TwitterException {

		return twitter.createFriendship(screenName);
	}

	public SavedSearch createSavedSearch(String query) throws TwitterException {

		return twitter.createSavedSearch(query);
	}

	public UserList createUserList(String listName, boolean isPublicList,
			String description) throws TwitterException {

		return twitter.createUserList(listName, isPublicList, description);
	}

	public UserList deleteUserListMember(int listId, int userId)
			throws TwitterException {

		return twitter.deleteUserListMember(listId, userId);
	}

	public User destroyBlock(int userId) throws TwitterException {

		return twitter.destroyBlock(userId);
	}

	public User destroyBlock(String screenName) throws TwitterException {

		return twitter.destroyBlock(screenName);
	}

	public DirectMessage destroyDirectMessage(int id) throws TwitterException {

		return twitter.destroyDirectMessage(id);
	}

	public Status destroyFavorite(long id) throws TwitterException {

		return twitter.destroyFavorite(id);
	}

	public User destroyFriendship(int userId) throws TwitterException {

		return twitter.destroyFriendship(userId);
	}

	public User destroyFriendship(String screenName) throws TwitterException {

		return twitter.destroyFriendship(screenName);
	}

	public SavedSearch destroySavedSearch(int id) throws TwitterException {

		return twitter.destroySavedSearch(id);
	}

	public Status destroyStatus(long statusId) throws TwitterException {

		return twitter.destroyStatus(statusId);
	}

	public UserList destroyUserList(int listId) throws TwitterException {

		return twitter.destroyUserList(listId);
	}

	public User disableNotification(int userId) throws TwitterException {

		return twitter.disableNotification(userId);
	}

	public User disableNotification(String screenName) throws TwitterException {

		return twitter.disableNotification(screenName);
	}

	public User enableNotification(int userId) throws TwitterException {

		return twitter.enableNotification(userId);
	}

	public User enableNotification(String screenName) throws TwitterException {

		return twitter.enableNotification(screenName);
	}

	public boolean existsBlock(int userId) throws TwitterException {

		return twitter.existsBlock(userId);
	}

	public boolean existsBlock(String screenName) throws TwitterException {

		return twitter.existsBlock(screenName);
	}

	public boolean existsFriendship(String userA, String userB)
			throws TwitterException {

		return twitter.existsFriendship(userA, userB);
	}

	public ResponseList<User> getBlockingUsers() throws TwitterException {

		return twitter.getBlockingUsers();
	}

	public ResponseList<User> getBlockingUsers(int page)
			throws TwitterException {

		return twitter.getBlockingUsers(page);
	}

	public IDs getBlockingUsersIDs() throws TwitterException {

		return twitter.getBlockingUsersIDs();
	}

	public Trends getCurrentTrends() throws TwitterException {

		return twitter.getCurrentTrends();
	}

	public Trends getCurrentTrends(boolean excludeHashTags)
			throws TwitterException {

		return twitter.getCurrentTrends(excludeHashTags);
	}

	public List<Trends> getDailyTrends() throws TwitterException {

		return twitter.getDailyTrends();
	}

	public List<Trends> getDailyTrends(Date date, boolean excludeHashTags)
			throws TwitterException {

		return twitter.getDailyTrends(date, excludeHashTags);
	}

	public ResponseList<DirectMessage> getDirectMessages()
			throws TwitterException {

		return twitter.getDirectMessages();
	}

	public ResponseList<DirectMessage> getDirectMessages(Paging paging)
			throws TwitterException {

		return twitter.getDirectMessages(paging);
	}

	public ResponseList<Status> getFavorites() throws TwitterException {

		return twitter.getFavorites();
	}

	public ResponseList<Status> getFavorites(int page) throws TwitterException {

		return twitter.getFavorites(page);
	}

	public ResponseList<Status> getFavorites(String id, int page)
			throws TwitterException {

		return twitter.getFavorites(id, page);
	}

	public ResponseList<Status> getFavorites(String id) throws TwitterException {

		return twitter.getFavorites(id);
	}

	public IDs getFollowersIDs() throws TwitterException {

		return twitter.getFollowersIDs();
	}

	public IDs getFollowersIDs(int userId, long cursor) throws TwitterException {

		return twitter.getFollowersIDs(userId, cursor);
	}

	public IDs getFollowersIDs(int userId) throws TwitterException {

		return twitter.getFollowersIDs(userId);
	}

	public IDs getFollowersIDs(long cursor) throws TwitterException {

		return twitter.getFollowersIDs(cursor);
	}

	public IDs getFollowersIDs(String screenName, long cursor)
			throws TwitterException {

		return twitter.getFollowersIDs(screenName, cursor);
	}

	public IDs getFollowersIDs(String screenName) throws TwitterException {

		return twitter.getFollowersIDs(screenName);
	}

	public PagableResponseList<User> getFollowersStatuses()
			throws TwitterException {

		return twitter.getFollowersStatuses();
	}

	public PagableResponseList<User> getFollowersStatuses(int userId,
			long cursor) throws TwitterException {

		return twitter.getFollowersStatuses(userId, cursor);
	}

	public PagableResponseList<User> getFollowersStatuses(int userId)
			throws TwitterException {

		return twitter.getFollowersStatuses(userId);
	}

	public PagableResponseList<User> getFollowersStatuses(long cursor)
			throws TwitterException {

		return twitter.getFollowersStatuses(cursor);
	}

	public PagableResponseList<User> getFollowersStatuses(String screenName,
			long cursor) throws TwitterException {

		return twitter.getFollowersStatuses(screenName, cursor);
	}

	public PagableResponseList<User> getFollowersStatuses(String screenName)
			throws TwitterException {

		return twitter.getFollowersStatuses(screenName);
	}

	public IDs getFriendsIDs() throws TwitterException {

		return twitter.getFriendsIDs();
	}

	public IDs getFriendsIDs(int userId, long cursor) throws TwitterException {

		return twitter.getFriendsIDs(userId, cursor);
	}

	public IDs getFriendsIDs(int userId) throws TwitterException {

		return twitter.getFriendsIDs(userId);
	}

	public IDs getFriendsIDs(long cursor) throws TwitterException {

		return twitter.getFriendsIDs(cursor);
	}

	public IDs getFriendsIDs(String screenName, long cursor)
			throws TwitterException {

		return twitter.getFriendsIDs(screenName, cursor);
	}

	public IDs getFriendsIDs(String screenName) throws TwitterException {

		return twitter.getFriendsIDs(screenName);
	}

	public PagableResponseList<User> getFriendsStatuses()
			throws TwitterException {

		return twitter.getFriendsStatuses();
	}

	public PagableResponseList<User> getFriendsStatuses(int userId, long cursor)
			throws TwitterException {

		return twitter.getFriendsStatuses(userId, cursor);
	}

	public PagableResponseList<User> getFriendsStatuses(int userId)
			throws TwitterException {

		return twitter.getFriendsStatuses(userId);
	}

	public PagableResponseList<User> getFriendsStatuses(long cursor)
			throws TwitterException {

		return twitter.getFriendsStatuses(cursor);
	}

	public PagableResponseList<User> getFriendsStatuses(String screenName,
			long cursor) throws TwitterException {

		return twitter.getFriendsStatuses(screenName, cursor);
	}

	public PagableResponseList<User> getFriendsStatuses(String screenName)
			throws TwitterException {

		return twitter.getFriendsStatuses(screenName);
	}

	public ResponseList<Status> getFriendsTimeline() throws TwitterException {

		return twitter.getFriendsTimeline();
	}

	public ResponseList<Status> getFriendsTimeline(Paging paging)
			throws TwitterException {

		return twitter.getFriendsTimeline(paging);
	}

	public ResponseList<Status> getHomeTimeline() throws TwitterException {

		return twitter.getHomeTimeline();
	}

	public ResponseList<Status> getHomeTimeline(Paging paging)
			throws TwitterException {

		return twitter.getHomeTimeline(paging);
	}

	public ResponseList<Status> getMentions() throws TwitterException {

		return twitter.getMentions();
	}

	public ResponseList<Status> getMentions(Paging paging)
			throws TwitterException {

		return twitter.getMentions(paging);
	}

	public AccessToken getOAuthAccessToken() throws TwitterException {

		return twitter.getOAuthAccessToken();
	}

	public synchronized AccessToken getOAuthAccessToken(
			RequestToken requestToken, String oauthVerifier)
			throws TwitterException {

		return twitter.getOAuthAccessToken(requestToken, oauthVerifier);
	}

	public synchronized AccessToken getOAuthAccessToken(
			RequestToken requestToken) throws TwitterException {

		return twitter.getOAuthAccessToken(requestToken);
	}

	public synchronized AccessToken getOAuthAccessToken(String token,
			String tokenSecret, String pin) throws TwitterException {

		return twitter.getOAuthAccessToken(token, tokenSecret, pin);
	}

	public synchronized AccessToken getOAuthAccessToken(String token,
			String tokenSecret) throws TwitterException {

		return twitter.getOAuthAccessToken(token, tokenSecret);
	}

	public AccessToken getOAuthAccessToken(String oauthVerifier)
			throws TwitterException {

		return twitter.getOAuthAccessToken(oauthVerifier);
	}

	public RequestToken getOAuthRequestToken() throws TwitterException {

		return twitter.getOAuthRequestToken();
	}

	public RequestToken getOAuthRequestToken(String callbackUrl)
			throws TwitterException {

		return twitter.getOAuthRequestToken(callbackUrl);
	}

	public ResponseList<Status> getPublicTimeline() throws TwitterException {

		return twitter.getPublicTimeline();
	}

	public RateLimitStatus getRateLimitStatus() throws TwitterException {

		return twitter.getRateLimitStatus();
	}

	public ResponseList<Status> getRetweetedByMe() throws TwitterException {

		return twitter.getRetweetedByMe();
	}

	public ResponseList<Status> getRetweetedByMe(Paging paging)
			throws TwitterException {

		return twitter.getRetweetedByMe(paging);
	}

	public ResponseList<Status> getRetweetedToMe() throws TwitterException {

		return twitter.getRetweetedToMe();
	}

	public ResponseList<Status> getRetweetedToMe(Paging paging)
			throws TwitterException {

		return twitter.getRetweetedToMe(paging);
	}

	public ResponseList<Status> getRetweets(long statusId)
			throws TwitterException {

		return twitter.getRetweets(statusId);
	}

	public ResponseList<Status> getRetweetsOfMe() throws TwitterException {

		return twitter.getRetweetsOfMe();
	}

	public ResponseList<Status> getRetweetsOfMe(Paging paging)
			throws TwitterException {

		return twitter.getRetweetsOfMe(paging);
	}

	public List<SavedSearch> getSavedSearches() throws TwitterException {

		return twitter.getSavedSearches();
	}

	public ResponseList<DirectMessage> getSentDirectMessages()
			throws TwitterException {

		return twitter.getSentDirectMessages();
	}

	public ResponseList<DirectMessage> getSentDirectMessages(Paging paging)
			throws TwitterException {

		return twitter.getSentDirectMessages(paging);
	}

	public Trends getTrends() throws TwitterException {

		return twitter.getTrends();
	}

	public PagableResponseList<User> getUserListMembers(
			String listOwnerScreenName, int listId, long cursor)
			throws TwitterException {

		return twitter.getUserListMembers(listOwnerScreenName, listId, cursor);
	}

	public PagableResponseList<UserList> getUserListMemberships(
			String listOwnerScreenName, long cursor) throws TwitterException {

		return twitter.getUserListMemberships(listOwnerScreenName, cursor);
	}

	public PagableResponseList<UserList> getUserLists(
			String listOwnerScreenName, long cursor) throws TwitterException {

		return twitter.getUserLists(listOwnerScreenName, cursor);
	}

	public ResponseList<Status> getUserListStatuses(String listOwnerScreenName,
			int id, Paging paging) throws TwitterException {

		return twitter.getUserListStatuses(listOwnerScreenName, id, paging);
	}

	public PagableResponseList<User> getUserListSubscribers(
			String listOwnerScreenName, int listId, long cursor)
			throws TwitterException {

		return twitter.getUserListSubscribers(listOwnerScreenName, listId,
				cursor);
	}

	public PagableResponseList<UserList> getUserListSubscriptions(
			String listOwnerScreenName, long cursor) throws TwitterException {

		return twitter.getUserListSubscriptions(listOwnerScreenName, cursor);
	}

	public ResponseList<Status> getUserTimeline() throws TwitterException {

		return twitter.getUserTimeline();
	}

	public ResponseList<Status> getUserTimeline(int userId, Paging paging)
			throws TwitterException {

		return twitter.getUserTimeline(userId, paging);
	}

	public ResponseList<Status> getUserTimeline(int userId)
			throws TwitterException {

		return twitter.getUserTimeline(userId);
	}

	public ResponseList<Status> getUserTimeline(Paging paging)
			throws TwitterException {

		return twitter.getUserTimeline(paging);
	}

	public ResponseList<Status> getUserTimeline(String screenName, Paging paging)
			throws TwitterException {

		return twitter.getUserTimeline(screenName, paging);
	}

	public ResponseList<Status> getUserTimeline(String screenName)
			throws TwitterException {

		return twitter.getUserTimeline(screenName);
	}

	public List<Trends> getWeeklyTrends() throws TwitterException {

		return twitter.getWeeklyTrends();
	}

	public List<Trends> getWeeklyTrends(Date date, boolean excludeHashTags)
			throws TwitterException {

		return twitter.getWeeklyTrends(date, excludeHashTags);
	}

	public boolean isOAuthEnabled() {

		return twitter.isOAuthEnabled();
	}

	public User reportSpam(int userId) throws TwitterException {

		return twitter.reportSpam(userId);
	}

	public User reportSpam(String screenName) throws TwitterException {

		return twitter.reportSpam(screenName);
	}

	public Status retweetStatus(long statusId) throws TwitterException {

		return twitter.retweetStatus(statusId);
	}

	public QueryResult search(Query query) throws TwitterException {

		return twitter.search(query);
	}

	public ResponseList<User> searchUsers(String query, int page)
			throws TwitterException {

		return twitter.searchUsers(query, page);
	}

	public DirectMessage sendDirectMessage(int userId, String text)
			throws TwitterException {

		return twitter.sendDirectMessage(userId, text);
	}

	public DirectMessage sendDirectMessage(String screenName, String text)
			throws TwitterException {

		return twitter.sendDirectMessage(screenName, text);
	}

	public void setOAuthAccessToken(AccessToken accessToken) {

		twitter.setOAuthAccessToken(accessToken);
	}

	public synchronized void setOAuthConsumer(String consumerKey,
			String consumerSecret) {

		twitter.setOAuthConsumer(consumerKey, consumerSecret);
	}

	public Relationship showFriendship(int sourceId, int targetId)
			throws TwitterException {

		return twitter.showFriendship(sourceId, targetId);
	}

	public Relationship showFriendship(String sourceScreenName,
			String targetScreenName) throws TwitterException {

		return twitter.showFriendship(sourceScreenName, targetScreenName);
	}

	public SavedSearch showSavedSearch(int id) throws TwitterException {

		return twitter.showSavedSearch(id);
	}

	public Status showStatus(long id) throws TwitterException {

		return twitter.showStatus(id);
	}

	public User showUser(int userId) throws TwitterException {

		return twitter.showUser(userId);
	}

	public User showUser(String screenName) throws TwitterException {

		return twitter.showUser(screenName);
	}

	public UserList showUserList(String listOwnerScreenName, int id)
			throws TwitterException {

		return twitter.showUserList(listOwnerScreenName, id);
	}

	public UserList subscribeUserList(String listOwnerScreenName, int listId)
			throws TwitterException {

		return twitter.subscribeUserList(listOwnerScreenName, listId);
	}

	public boolean test() throws TwitterException {

		return twitter.test();
	}

	@Override
	public String toString() {

		return twitter.toString();
	}

	public UserList unsubscribeUserList(String listOwnerScreenName, int listId)
			throws TwitterException {

		return twitter.unsubscribeUserList(listOwnerScreenName, listId);
	}

	public User updateDeliveryDevice(Device device) throws TwitterException {

		return twitter.updateDeliveryDevice(device);
	}

	public User updateProfile(String name, String email, String url,
			String location, String description) throws TwitterException {

		return twitter.updateProfile(name, email, url, location, description);
	}

	public User updateProfileBackgroundImage(File image, boolean tile)
			throws TwitterException {

		return twitter.updateProfileBackgroundImage(image, tile);
	}

	public User updateProfileColors(String profileBackgroundColor,
			String profileTextColor, String profileLinkColor,
			String profileSidebarFillColor, String profileSidebarBorderColor)
			throws TwitterException {

		return twitter.updateProfileColors(profileBackgroundColor,
				profileTextColor, profileLinkColor, profileSidebarFillColor,
				profileSidebarBorderColor);
	}

	public User updateProfileImage(File image) throws TwitterException {

		return twitter.updateProfileImage(image);
	}

	public Status updateStatus(String status, GeoLocation location)
			throws TwitterException {

		return twitter.updateStatus(status, location);
	}

	public Status updateStatus(String status, long inReplyToStatusId,
			GeoLocation location) throws TwitterException {

		return twitter.updateStatus(status, inReplyToStatusId, location);
	}

	public Status updateStatus(String status, long inReplyToStatusId)
			throws TwitterException {

		return twitter.updateStatus(status, inReplyToStatusId);
	}

	public Status updateStatus(String status) throws TwitterException {

		return twitter.updateStatus(status);
	}

	public UserList updateUserList(int listId, String newListName,
			boolean isPublicList, String newDescription)
			throws TwitterException {

		return twitter.updateUserList(listId, newListName, isPublicList,
				newDescription);
	}

	public User verifyCredentials() throws TwitterException {

		return twitter.verifyCredentials();
	}

	public Date getCreatedAt() {

		return user.getCreatedAt();
	}

	public String getDescription() {

		return user.getDescription();
	}

	public int getFavouritesCount() {

		return user.getFavouritesCount();
	}

	public int getFollowersCount() {

		return user.getFollowersCount();
	}

	public int getFriendsCount() {

		return user.getFriendsCount();
	}

	public int getId() {

		return user.getId();
	}

	public Bitmap getImage(URL url) {

		return user.getImage(url);
	}

	public String getLocation() {

		return user.getLocation();
	}

	public String getName() {

		return user.getName();
	}

	public Bitmap getPic() {

		return user.getPic();
	}

	public String getProfileBackgroundImageUrl() {

		return user.getProfileBackgroundImageUrl();
	}

	public URL getProfileImageURL() {

		return user.getProfileImageURL();
	}

	public Status getStatus() {

		return user.getStatus();
	}

	public int getStatusesCount() {

		return user.getStatusesCount();
	}

	public String getTimeZone() {

		return user.getTimeZone();
	}

	public URL getURL() {

		return user.getURL();
	}

	public int getUtcOffset() {

		return user.getUtcOffset();
	}

	public boolean isGeoEnabled() {

		return user.isGeoEnabled();
	}

	public boolean isProfileBackgroundTiled() {

		return user.isProfileBackgroundTiled();
	}

	public boolean isProtected() {

		return user.isProtected();
	}

	public boolean isVerified() {

		return user.isVerified();
	}

	public void setPic(Bitmap picture) {

		user.setPic(picture);
	}

	public Twitter getTwitter() {
		return twitter;
	}

	public void setTwitter(Twitter twitter) {
		this.twitter = twitter;
	}

	public TwitterUser getUser() {
		return user;
	}

	public void setUser(TwitterUser user) {
		this.user = user;
	}
}
